home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / dev / moni / systemviewer.lha / SysScreens.c < prev    next >
C/C++ Source or Header  |  2001-04-25  |  47KB  |  1,822 lines
  1. /****h* SysScreens.c [1.1] ********************************************
  2. *
  3. * NAME
  4. *    SysScreens.c - display info about all open screens & windows
  5. *
  6. * DESCRIPTION
  7. *    Allow the user to view a list of all Screens & Windows that are
  8. *    currently open to Intuition.  The user can close any Window or
  9. *    Screen safely(?).
  10. *
  11. * FUNCTIONAL INTERFACE:
  12. *
  13. *    PUBLIC void CloseTheScreen( struct Screen *scr );
  14. *
  15. *    PUBLIC void CloseTheWindow( struct Window *wind );
  16. *
  17. *    PUBLIC int HandleScreenLV( void );
  18. *
  19. ***********************************************************************
  20. *
  21. */
  22.  
  23. #include <stdio.h>
  24. #include <string.h>
  25.  
  26. #include <exec/types.h>
  27. #include <exec/lists.h>
  28. #include <exec/nodes.h>
  29.  
  30. #include <dos/dosextens.h>
  31.  
  32. #include <AmigaDOSErrs.h>
  33.  
  34. #include <intuition/intuitionbase.h>
  35. #include <intuition/classes.h>
  36. #include <intuition/classusr.h>
  37. #include <intuition/gadgetclass.h>
  38.  
  39. #include <libraries/gadtools.h>
  40.  
  41. #include <graphics/displayinfo.h>
  42. #include <graphics/gfxbase.h>
  43.  
  44. #include <clib/exec_protos.h>
  45. #include <clib/intuition_protos.h>
  46. #include <clib/gadtools_protos.h>
  47. #include <clib/graphics_protos.h>
  48. #include <clib/utility_protos.h>
  49. #include <clib/diskfont_protos.h>
  50.  
  51. #include "CPGM:GlobalObjects/CommonFuncs.h"
  52.  
  53. #include "SysLists.h"
  54.  
  55. #define MAX_HEIGHT 380
  56.  
  57. PRIVATE int HandleWindowInfo( void *structptr, int whichdisplay );
  58.  
  59. PRIVATE char ver[] = "\0$VER: SysScreens 1.1 (25-Apr-2001) by J.T. Steichen\0";
  60.  
  61. PRIVATE struct Window *IWnd = NULL;
  62.  
  63. PRIVATE UWORD ILeft   = 0;
  64. PRIVATE UWORD ITop    = 32;
  65. PRIVATE UWORD IWidth  = 640;
  66. PRIVATE UWORD IHeight = MAX_HEIGHT;
  67.  
  68. PRIVATE UBYTE *IWTitle = "System Screens & Windows Full Info:";
  69.  
  70. #define XPOS    6
  71.  
  72. PRIVATE struct Gadget *ScrGadgets[ SCR_CNT ];
  73.  
  74. PRIVATE UBYTE *WTitle = "System Screens & Windows Info:";
  75.  
  76. PRIVATE UWORD StrYPos[32] = { 0, };
  77.  
  78. // --------------------------------------------------------------------
  79.  
  80. PRIVATE UBYTE *ttl = "Address     Pos     Size    Flags    IDCMP       Title";
  81.  
  82. #define MAXNODE    100
  83. #define NODELENGTH 80
  84.  
  85. PRIVATE struct List ScrList;
  86.  
  87. PRIVATE struct Node ScrNode;
  88. PRIVATE struct Node ScrNodes[ MAXNODE ]              = { NULL, };
  89. PRIVATE UBYTE       NodeStrs[ MAXNODE * NODELENGTH ] = "";
  90.  
  91. PRIVATE struct ListViewMem lvm = { 0, };
  92.     
  93. // --------------------------------------------------------------------
  94.  
  95. PRIVATE UWORD ScrGTypes[] = {
  96.  
  97.    LISTVIEW_KIND, BUTTON_KIND, BUTTON_KIND, 
  98.    BUTTON_KIND,   BUTTON_KIND, TEXT_KIND
  99. };
  100.  
  101. PRIVATE int SLVClicked(    int itemnum );
  102. PRIVATE int UpdateClicked( int dummy   );
  103. PRIVATE int CancelClicked( int dummy   );
  104. PRIVATE int MoreClicked(   int dummy   );
  105. PRIVATE int CloseClicked(  int dummy   );
  106.  
  107. PRIVATE struct NewGadget ScrNGad[] = {
  108.  
  109.      2,   3, 627, 200,               NULL, NULL, ScrLV,
  110.    0,           NULL, (APTR) SLVClicked,
  111.  
  112.      4, 205,  71, 17, (UBYTE *) "_Update", NULL, ScrUpdate,
  113.    PLACETEXT_IN, NULL, (APTR) UpdateClicked,
  114.  
  115.     89, 205,  72, 17, (UBYTE *) "_More",   NULL, ScrMore,
  116.    PLACETEXT_IN, NULL, (APTR) MoreClicked,
  117.  
  118.    255, 205,  72, 17, (UBYTE *) "Close",   NULL, ScrClose,
  119.    PLACETEXT_IN, NULL, (APTR) CloseClicked,
  120.  
  121.    554, 205,  72, 17, (UBYTE *) "_Cancel", NULL, ScrCancel,
  122.    PLACETEXT_IN, NULL, (APTR) CancelClicked,
  123.  
  124.      5, 228, 620, 17,                NULL, NULL, ScrSelection, 
  125.    0, NULL, NULL
  126. };
  127.  
  128. PRIVATE ULONG ScrGTags[] = {
  129.  
  130.    GTLV_ShowSelected, NULL, (LAYOUTA_Spacing), 2, (TAG_DONE),
  131.  
  132.    (GT_Underscore), '_', (TAG_DONE),
  133.    (GT_Underscore), '_', (GA_Disabled), TRUE, (TAG_DONE),
  134.  
  135.    (GA_Disabled), TRUE, (TAG_DONE),
  136.  
  137.    (GT_Underscore), '_', (TAG_DONE),
  138.  
  139.    (GTTX_Border), TRUE, (TAG_DONE)
  140. };
  141.  
  142. // -----------------------------------------------------------------
  143.  
  144. PRIVATE void WriteText( char *string, int xpos, int ypos, int color ) 
  145. {
  146.    struct RastPort  *rp = IWnd->RPort;
  147.    struct IntuiText  outtxt;
  148.  
  149.    outtxt.FrontPen  = color;
  150.    outtxt.BackPen   = 0;
  151.    outtxt.DrawMode  = JAM1;
  152.    outtxt.LeftEdge  = 0;
  153.    outtxt.TopEdge   = 0;
  154.    outtxt.ITextFont = Font;
  155.    outtxt.NextText  = NULL;
  156.    outtxt.IText     = (UBYTE *) string;
  157.  
  158.    PrintIText( rp, &outtxt, xpos, ypos );
  159.  
  160.    return;
  161. }
  162.  
  163. PRIVATE char typ[10], *pgmtype = &typ[0];
  164.  
  165. PRIVATE char *GetTask_Process( UBYTE type )
  166. {
  167.    if (type == NT_TASK)
  168.       strcpy( pgmtype, "TASK" );
  169.    else if (type == NT_PROCESS)
  170.       strcpy( pgmtype, "PROCESS" );
  171.    else   
  172.       strcpy( pgmtype, "TASK" );
  173.  
  174.    return( pgmtype );
  175. }
  176.  
  177. PRIVATE BOOL CheckBit( int flags, int bit )
  178. {
  179.    if ((flags & bit) == bit)
  180.       return( TRUE );
  181.    else
  182.       return( FALSE );
  183. }
  184.  
  185. PRIVATE char ts[10], *taskstate = &ts[0];
  186. PRIVATE BOOL DispTaskFlag = TRUE;
  187.  
  188. PRIVATE char *GetTaskState( struct Task *t )
  189. {
  190.    if (t == NULL)
  191.       return( "INVALID" );
  192.  
  193.    switch (t->tc_State)
  194.       {
  195.       case TS_INVALID:
  196.          strcpy( taskstate, "INVALID" );  // Stack won't be right.
  197.          DispTaskFlag = FALSE;
  198.          break;
  199.          
  200.       case TS_ADDED:
  201.          strcpy( taskstate, "ADDED" );
  202.          DispTaskFlag = TRUE;
  203.          break;
  204.          
  205.       case TS_RUN:
  206.          strcpy( taskstate, "RUNNING" );
  207.          DispTaskFlag = TRUE;
  208.          break;
  209.          
  210.       case TS_READY:
  211.          strcpy( taskstate, "READY" );
  212.          DispTaskFlag = TRUE;
  213.          break;
  214.          
  215.       case TS_WAIT:
  216.          strcpy( taskstate, "WAITING" );
  217.          DispTaskFlag = TRUE;
  218.          break;
  219.          
  220.       case TS_EXCEPT:
  221.          strcpy( taskstate, "EXCEPTION" );
  222.          DispTaskFlag = TRUE;
  223.          break;
  224.          
  225.       case TS_REMOVED:
  226.          strcpy( taskstate, "REMOVED" );
  227.          DispTaskFlag = TRUE;
  228.          break;
  229.       }
  230.  
  231.    return( taskstate );
  232. }
  233.  
  234. PRIVATE void SetTaskFlags( struct Task *t, char *str )
  235. {
  236.    *str = '\0';
  237.  
  238.    if (CheckBit( t->tc_Flags, TF_PROCTIME ) == TRUE)
  239.       strcpy( str, "TF_PROCTIME " );
  240.    
  241.    if (CheckBit( t->tc_Flags, TF_ETASK ) == TRUE)
  242.       strcat( str, "TF_ETASK " );
  243.  
  244.    if (CheckBit( t->tc_Flags, TF_STACKCHK ) == TRUE)
  245.       strcat( str, "TF_STACKCHK " );
  246.  
  247.    if (CheckBit( t->tc_Flags, TF_EXCEPT ) == TRUE)
  248.       strcat( str, "TF_EXCEPT " );
  249.  
  250.    if (CheckBit( t->tc_Flags, TF_SWITCH ) == TRUE)
  251.       strcat( str, "TF_SWITCH " );
  252.  
  253.    if (CheckBit( t->tc_Flags, TF_LAUNCH ) == TRUE)
  254.       strcat( str, "TF_LAUNCH" );
  255.  
  256.    return;
  257. }
  258.  
  259.  
  260. #define B2APTR( bptr ) ((bptr) << 2)
  261.  
  262. PRIVATE void WriteTask( void *ptr )
  263. {
  264.    IMPORT UWORD StrYPos[];
  265.    
  266.    struct Task    *task    = (struct Task *) ptr;
  267.    struct Process *process = NULL;
  268.  
  269.    char t[82], *title = &t[0];
  270.    char s[82], *str   = &s[0];
  271.  
  272.    int  size = 0;
  273.    
  274.    if (task == NULL)
  275.       return; 
  276.  
  277.    sprintf( title, "%s: (%08LX) -> %-40.40s", 
  278.             GetTask_Process( task->tc_Node.ln_Type ),
  279.             task, task->tc_Node.ln_Name
  280.           );
  281.  
  282.    DisplayTitle( Wnd, title );
  283.  
  284.    // Common (to Task & Process) data to display:
  285.    if ((task->tc_Node.ln_Type == NT_TASK) 
  286.        || (task->tc_Node.ln_Type == NT_PROCESS))
  287.       {
  288.       sprintf( str, "STATE: %s Priority: %4d", 
  289.                GetTaskState( task ),
  290.                task->tc_Node.ln_Pri 
  291.              );
  292.  
  293.       WriteText( str, XPOS, StrYPos[0], 2 );
  294.  
  295.       sprintf( str, "SigAlloc: %08LX SigWait : %08LX SigRecvd : %08LX SigExcept: %08LX", 
  296.                task->tc_SigAlloc, task->tc_SigWait, 
  297.                task->tc_SigRecvd, task->tc_SigExcept
  298.              );
  299.  
  300.       WriteText( str, XPOS, StrYPos[1], 1 );
  301.  
  302.       sprintf( str, "TrapData: %08LX TrapCode: %08LX TrapAlloc: %08LX TrapAble : %08LX",
  303.                task->tc_TrapData, task->tc_TrapCode, 
  304.                task->tc_TrapAlloc, task->tc_TrapAble
  305.              );
  306.  
  307.       WriteText( str, XPOS, StrYPos[2], 1 );
  308.  
  309.       sprintf( str, "Switch(): %08LX Launch(): %08LX UserData : %08LX", 
  310.                task->tc_Switch, task->tc_Launch, 
  311.                task->tc_UserData
  312.              );
  313.  
  314.       WriteText( str, XPOS, StrYPos[3], 2 );
  315.  
  316.       sprintf( str, "ExceptData: %08LX ExceptCode: %08LX", 
  317.                task->tc_ExceptData, task->tc_ExceptCode
  318.              );
  319.  
  320.       WriteText( str, XPOS, StrYPos[5], 1 );
  321.  
  322.       size = (int) task->tc_SPUpper - (int) task->tc_SPLower;
  323.  
  324.       sprintf( str, "SPReg     : %08LX SPUpper   : %08LX SPLower: %08LX size: %d",
  325.                task->tc_SPReg, task->tc_SPUpper, 
  326.                task->tc_SPLower, size
  327.              );
  328.  
  329.       WriteText( str, XPOS, StrYPos[6], 2 );
  330.  
  331.       sprintf( str, "IDNestCnt: %-08d TDNestCnt: %3d",
  332.                task->tc_IDNestCnt, task->tc_TDNestCnt
  333.              );
  334.  
  335.       WriteText( str, XPOS, StrYPos[8], 1 );
  336.  
  337.       sprintf( str, "MemEntry : %08LX", task->tc_MemEntry.lh_Head );
  338.  
  339.       WriteText( str, XPOS, StrYPos[9], 1 );
  340.  
  341.       WriteText( "Flags:", XPOS, StrYPos[10], 3 );
  342.  
  343.       SetTaskFlags( task, str );
  344.  
  345.       WriteText( str, XPOS, StrYPos[11], 1 );
  346.  
  347.       if (task->tc_Node.ln_Type == NT_TASK) 
  348.          WriteText( "Press Close Gadget when you're done!", 
  349.                     150, StrYPos[12], 2 
  350.                   ); 
  351.       }
  352.  
  353.    // Process additions to display:
  354.    if (task->tc_Node.ln_Type == NT_PROCESS)
  355.       {
  356.       char   pn[256], *path = &pn[0];
  357.       UBYTE *ttl = NULL;
  358.             
  359.       process = (struct Process *) ptr;
  360.  
  361.       WriteText( "Process Structure:", XPOS, StrYPos[12], 3 );  
  362.  
  363.       if ((struct Window *) process->pr_WindowPtr != NULL)
  364.          ttl = ((struct Window *) process->pr_WindowPtr)->Title;
  365.       else
  366.          ttl = "*NO TITLE!*";
  367.  
  368.       sprintf( str, "WindowPtr  : %08LX Title: %-40.40s", 
  369.                process->pr_WindowPtr, 
  370.                (strlen( ttl ) > 0) ? ttl : (UBYTE *) "*NO TITLE!*"
  371.              );
  372.  
  373.       WriteText( str, XPOS, StrYPos[13], 2 );
  374.  
  375.       if (process->pr_CurrentDir != NULL)
  376.          (void) NameFromLock( process->pr_CurrentDir, path, 255 );
  377.           
  378.       sprintf( str, "CurrentDir : %08LX Path : %-40.40s", 
  379.                B2APTR( process->pr_CurrentDir ),
  380.                (path == NULL) ? "*NO PATH*" : path
  381.              );
  382.  
  383.       WriteText( str, XPOS, StrYPos[14], 2 );
  384.  
  385.       sprintf( str, "MsgPort    : %08LX SegList       : %08LX", 
  386.                process->pr_MsgPort, B2APTR( process->pr_SegList )
  387.              );
  388.  
  389.       WriteText( str, XPOS, StrYPos[15], 1 );
  390.  
  391.       sprintf( str, "StackBase  : %08LX StackSize     : %d", 
  392.                B2APTR( process->pr_StackBase ), process->pr_StackSize
  393.              );
  394.  
  395.       WriteText( str, XPOS, StrYPos[16], 1 );
  396.  
  397.       sprintf( str, "CIS        : %08LX COS           : %08LX", 
  398.                B2APTR( process->pr_CIS ), B2APTR( process->pr_COS )
  399.              );
  400.  
  401.       WriteText( str, XPOS, StrYPos[17], 1 );
  402.  
  403.       sprintf( str, "ConsoleTask: %08LX FileSystemTask: %08LX", 
  404.                process->pr_ConsoleTask, 
  405.                process->pr_FileSystemTask
  406.              );
  407.  
  408.       WriteText( str, XPOS, StrYPos[18], 1 );
  409.  
  410.       sprintf( str, "PktWait    : %08LX ReturnAddr    : %08LX", 
  411.                process->pr_PktWait, 
  412.                process->pr_ReturnAddr
  413.              );
  414.  
  415.       WriteText( str, XPOS, StrYPos[19], 1 );
  416.  
  417.       sprintf( str, "Arguments -> %-60.60s", 
  418.                (process->pr_Arguments == NULL) ? (UBYTE *) "*NO ARGS!*" 
  419.                                                : process->pr_Arguments
  420.              );
  421.  
  422.       WriteText( str, XPOS, StrYPos[20], 2 );
  423.  
  424.       sprintf( str, "GlobVec    : %08LX CLI           : %08LX", 
  425.                process->pr_GlobVec, 
  426.                B2APTR( process->pr_CLI )
  427.              );
  428.  
  429.       WriteText( str, XPOS, StrYPos[21], 1 );
  430.  
  431.       // CLI additional information: 
  432.  
  433.       if (process->pr_CLI != NULL)
  434.          {
  435.          struct CommandLineInterface *cli = NULL;
  436.          BOOL                         iflag = FALSE, bflag = FALSE;
  437.  
  438.          cli = (struct CommandLineInterface *) (process->pr_CLI << 2);
  439.  
  440.          WriteText( "CommandLineInterface structure:", 
  441.                     XPOS, StrYPos[22], 3
  442.                   );
  443.  
  444.          sprintf( str, "CommandDir   : %08LX", 
  445.                   B2APTR( cli->cli_CommandDir )
  446.                 );
  447.  
  448.          WriteText( str, XPOS, StrYPos[23], 1 );
  449.  
  450.          sprintf( str, "StandardInput: %08LX StandardOutput: %08LX", 
  451.                   B2APTR( cli->cli_StandardInput ),
  452.                   B2APTR( cli->cli_StandardOutput )
  453.                 );
  454.  
  455.          WriteText( str, XPOS, StrYPos[24], 1 );
  456.  
  457.          sprintf( str, "CurrentInput : %08LX CurrentOutput : %08LX", 
  458.                   B2APTR( cli->cli_CurrentInput  ),
  459.                   B2APTR( cli->cli_CurrentOutput )
  460.                 );
  461.  
  462.          WriteText( str, XPOS, StrYPos[25], 1 );
  463.  
  464.          if (cli->cli_Interactive != FALSE)
  465.             iflag = TRUE;
  466.             
  467.          if (cli->cli_Background != FALSE)
  468.             bflag = TRUE;
  469.             
  470.          sprintf( str, "Module       : %08LX %s %s", 
  471.                   B2APTR( cli->cli_Module ),
  472.                   (bflag == TRUE) ? "BACKGROUND" : "",
  473.                   (iflag == TRUE) ? "& INTERACTIVE" : ""
  474.                 );
  475.  
  476.          WriteText( str, XPOS, StrYPos[26], 1 );
  477.          }
  478.  
  479.       WriteText( "Press Close Gadget when you're done!", 
  480.                  150, StrYPos[27], 2 
  481.                ); 
  482.       }
  483.  
  484.    return;
  485. }
  486.  
  487.  
  488. PRIVATE void CountGadgets( struct Window *w, int *bgad, 
  489.                            int *sgad, int *pgad
  490.                          )
  491. {
  492.    struct Gadget *first = w->FirstGadget;
  493.    
  494.    while (first != NULL)
  495.       {
  496.       switch (first->GadgetType & 0x07)
  497.          {
  498.          case BOOLGADGET:
  499.             *bgad += 1;
  500.             break; 
  501.  
  502.          case STRGADGET:
  503.             *sgad += 1;
  504.             break; 
  505.  
  506.          case PROPGADGET:
  507.             *pgad += 1;
  508.             break; 
  509.          }
  510.           
  511.       first = first->NextGadget;
  512.       }
  513.  
  514.    return;
  515. }
  516.  
  517. PRIVATE void CountMenus( struct Window *w, int *m, int *mi )
  518. {
  519.    struct Menu     *menu  = w->MenuStrip;
  520.    struct MenuItem *mitem = NULL;
  521.  
  522.    while (menu != NULL)
  523.       {
  524.       *m += 1;
  525.       mitem = menu->FirstItem;
  526.       
  527.       while (mitem != NULL)
  528.          {
  529.          *mi += 1;
  530.          
  531.          if (mitem->SubItem != NULL)
  532.             {
  533.             struct MenuItem *subs = mitem->SubItem;
  534.             
  535.             while (subs != NULL)
  536.                {
  537.                *mi += 1;
  538.                
  539.                subs = subs->NextItem;
  540.                }
  541.             }
  542.  
  543.          mitem = mitem->NextItem;
  544.          }
  545.       
  546.       menu = menu->NextMenu;
  547.       }
  548.  
  549.    return;
  550. }
  551.  
  552. PRIVATE void SetScreenFlagString( char *str, struct Screen *s )
  553. {
  554.    if (CheckBit( s->Flags, CUSTOMSCREEN ) == TRUE)
  555.       strcpy( str, "CUSTOMSCREEN  " );
  556.    else
  557.       strcpy( str, "WBENCHSCREEN  " );
  558.  
  559.    if (CheckBit( s->Flags, SHOWTITLE ) == TRUE)
  560.       strcat( str, "SHOWTITLE  " );
  561.  
  562.    if (CheckBit( s->Flags, BEEPING ) == TRUE)
  563.       strcat( str, "BEEPING  " );
  564.  
  565.    if (CheckBit( s->Flags, CUSTOMBITMAP ) == TRUE)
  566.       strcat( str, "CUSTOMBITMAP" );
  567.  
  568.    return;
  569. }
  570.  
  571.  
  572. PRIVATE void SetScreenViewMode1( char *str, struct Screen *s )
  573. {
  574.    *str = '\0';
  575.  
  576.    if (CheckBit( s->ViewPort.Modes, HIRES ) == TRUE)
  577.       strcpy( str, "HIRES  " );
  578.  
  579.    if (CheckBit( s->ViewPort.Modes, SPRITES ) == TRUE)
  580.       strcat( str, "SPRITES  " );
  581.  
  582.    if (CheckBit( s->ViewPort.Modes, VP_HIDE ) == TRUE)
  583.       strcat( str, "VP_HIDE  " );
  584.  
  585.    if (CheckBit( s->ViewPort.Modes, EXTENDED_MODE ) == TRUE)
  586.       strcat( str, "EXTENDED  " );
  587.  
  588.    if (CheckBit( s->ViewPort.Modes, HAM ) == TRUE)
  589.       strcat( str, "HAM  " );
  590.  
  591.    if (CheckBit( s->ViewPort.Modes, DUALPF ) == TRUE)
  592.       strcat( str, "DUALPF  " );
  593.  
  594.    if (CheckBit( s->ViewPort.Modes, GENLOCK_AUDIO ) == TRUE)
  595.       strcat( str, "GENLOCK_AUDIO  " );
  596.  
  597.    if (CheckBit( s->ViewPort.Modes, PFBA ) == TRUE)
  598.       strcat( str, "PFBA" );
  599.  
  600.    return;
  601. }
  602.  
  603. PRIVATE void SetScreenViewMode2( char *str, struct Screen *s )
  604. {
  605.    *str = '\0';
  606.    
  607.    if (CheckBit( s->ViewPort.Modes, LACE ) == TRUE)
  608.       strcpy( str, "LACE  " );
  609.  
  610.    if (CheckBit( s->ViewPort.Modes, DOUBLESCAN ) == TRUE)
  611.       strcat( str, "DOUBLESCAN  " );
  612.  
  613.    if (CheckBit( s->ViewPort.Modes, SUPERHIRES ) == TRUE)
  614.       strcat( str, "SUPERHIRES  " );
  615.  
  616.    if (CheckBit( s->ViewPort.Modes, EXTRA_HALFBRITE ) == TRUE)
  617.       strcat( str, "EXTRA_HALFBRITE  " );
  618.  
  619.    if (CheckBit( s->ViewPort.Modes, GENLOCK_VIDEO ) == TRUE)
  620.       strcat( str, "GENLOCK_VIDEO" );
  621.  
  622.    return;
  623. }
  624.  
  625. PRIVATE void SetWindowFlags1( struct Window *w, char *str )
  626. {
  627.    *str = '\0';
  628.  
  629.    if (CheckBit( w->Flags, WFLG_SIZEGADGET ) == TRUE)
  630.       strcpy( str, "WFLG_SIZEGADGET " );
  631.  
  632.    if (CheckBit( w->Flags, WFLG_DRAGBAR ) == TRUE)
  633.       strcat( str, "WFLG_DRAGBAR " );
  634.  
  635.    if (CheckBit( w->Flags, WFLG_DEPTHGADGET ) == TRUE)
  636.       strcat( str, "WFLG_DEPTHGADGET " );
  637.  
  638.    if (CheckBit( w->Flags, WFLG_CLOSEGADGET ) == TRUE)
  639.       strcat( str, "WFLG_CLOSEGADGET" );
  640.  
  641.    return;
  642. }
  643.  
  644. PRIVATE void SetWindowFlags2( struct Window *w, char *str )
  645. {
  646.    *str = '\0';
  647.  
  648.    if (CheckBit( w->Flags, WFLG_SMART_REFRESH ) == TRUE)
  649.       strcpy( str, "WFLG_SMART_REFRESH " );
  650.  
  651.    if (CheckBit( w->Flags, WFLG_SIMPLE_REFRESH ) == TRUE)
  652.       strcat( str, "WFLG_SIMPLE_REFRESH " );
  653.  
  654.    if (CheckBit( w->Flags, WFLG_SUPER_BITMAP ) == TRUE)
  655.       strcat( str, "WFLG_SUPER_BITMAP " );
  656.  
  657.    if (CheckBit( w->Flags, WFLG_OTHER_REFRESH ) == TRUE)
  658.       strcat( str, "WFLG_OTHER_REFRESH " );
  659.  
  660.    if (CheckBit( w->Flags, WFLG_GIMMEZEROZERO ) == TRUE)
  661.       strcat( str, "WFLG_GIMMEZEROZERO" );
  662.  
  663.    return;
  664. }
  665.  
  666. PRIVATE void SetWindowFlags3( struct Window *w, char *str )
  667. {
  668.    *str = '\0';
  669.  
  670.    if (CheckBit( w->Flags, WFLG_BACKDROP ) == TRUE)
  671.       strcpy( str, "WFLG_BACKDROP " );
  672.  
  673.    if (CheckBit( w->Flags, WFLG_REPORTMOUSE ) == TRUE)
  674.       strcat( str, "WFLG_REPORTMOUSE " );
  675.  
  676.    if (CheckBit( w->Flags, WFLG_BORDERLESS ) == TRUE)
  677.       strcat( str, "WFLG_BORDERLESS " );
  678.  
  679.    if (CheckBit( w->Flags, WFLG_ACTIVATE ) == TRUE)
  680.       strcat( str, "WFLG_ACTIVATE " );
  681.  
  682.    if (CheckBit( w->Flags, WFLG_SIZEBRIGHT ) == TRUE)
  683.       strcat( str, "WFLG_SIZEBRIGHT" );
  684.  
  685.    if (CheckBit( w->Flags, WFLG_SIZEBBOTTOM ) == TRUE)
  686.       strcat( str, "WFLG_SIZEBBOTTOM" );
  687.  
  688.    return;
  689. }
  690.  
  691. PRIVATE void SetWindowFlags4( struct Window *w, char *str )
  692. {
  693.    *str = '\0';
  694.  
  695.    if (CheckBit( w->Flags, WFLG_RMBTRAP ) == TRUE)
  696.       strcpy( str, "WFLG_RMBTRAP " );
  697.  
  698.    if (CheckBit( w->Flags, WFLG_NOCAREREFRESH ) == TRUE)
  699.       strcat( str, "WFLG_NOCAREREFRESH " );
  700.  
  701.    if (CheckBit( w->Flags, WFLG_WINDOWACTIVE ) == TRUE)
  702.       strcat( str, "WFLG_WINDOWACTIVE " );
  703.  
  704.    if (CheckBit( w->Flags, WFLG_WBENCHWINDOW ) == TRUE)
  705.       strcat( str, "WFLG_WBENCHWINDOW " );
  706.  
  707.    if (CheckBit( w->Flags, WFLG_HASZOOM ) == TRUE)
  708.       strcat( str, "WFLG_HASZOOM " );
  709.  
  710.    if (CheckBit( w->Flags, WFLG_ZOOMED ) == TRUE)
  711.       strcat( str, "WFLG_ZOOMED" );
  712.  
  713.    return;
  714. }
  715.  
  716. PRIVATE void SetIDCMPFlags1( struct Window *w, char *str )
  717. {
  718.    *str = '\0';
  719.  
  720.    if (CheckBit( w->IDCMPFlags, IDCMP_SIZEVERIFY ) == TRUE)
  721.       strcpy( str, "IDCMP_SIZEVERIFY " );
  722.  
  723.    if (CheckBit( w->IDCMPFlags, IDCMP_NEWSIZE ) == TRUE)
  724.       strcat( str, "IDCMP_NEWSIZE " );
  725.  
  726.    if (CheckBit( w->IDCMPFlags, IDCMP_REFRESHWINDOW ) == TRUE)
  727.       strcat( str, "IDCMP_REFRESHWINDOW " );
  728.  
  729.    if (CheckBit( w->IDCMPFlags, IDCMP_MOUSEBUTTONS ) == TRUE)
  730.       strcat( str, "IDCMP_MOUSEBUTTONS" );
  731.  
  732.    return;
  733. }
  734.  
  735. PRIVATE void SetIDCMPFlags2( struct Window *w, char *str )
  736. {
  737.    *str = '\0';
  738.  
  739.    if (CheckBit( w->IDCMPFlags, IDCMP_MOUSEMOVE ) == TRUE)
  740.       strcpy( str, "IDCMP_MOUSEMOVE " );
  741.  
  742.    if (CheckBit( w->IDCMPFlags, IDCMP_GADGETDOWN ) == TRUE)
  743.       strcat( str, "IDCMP_GADGETDOWN " );
  744.  
  745.    if (CheckBit( w->IDCMPFlags, IDCMP_GADGETUP ) == TRUE)
  746.       strcat( str, "IDCMP_GADGETUP " );
  747.  
  748.    if (CheckBit( w->IDCMPFlags, IDCMP_REQSET ) == TRUE)
  749.       strcat( str, "IDCMP_REQSET" );
  750.  
  751.    return;
  752. }
  753.  
  754. PRIVATE void SetIDCMPFlags3( struct Window *w, char *str )
  755. {
  756.    *str = '\0';
  757.  
  758.    if (CheckBit( w->IDCMPFlags, IDCMP_MENUPICK ) == TRUE)
  759.       strcpy( str, "IDCMP_MENUPICK " );
  760.  
  761.    if (CheckBit( w->IDCMPFlags, IDCMP_CLOSEWINDOW ) == TRUE)
  762.       strcat( str, "IDCMP_CLOSEWINDOW " );
  763.  
  764.    if (CheckBit( w->IDCMPFlags, IDCMP_RAWKEY ) == TRUE)
  765.       strcat( str, "IDCMP_RAWKEY " );
  766.  
  767.    if (CheckBit( w->IDCMPFlags, IDCMP_REQVERIFY ) == TRUE)
  768.       strcat( str, "IDCMP_REQVERIFY" );
  769.  
  770.    return;
  771. }
  772.  
  773. PRIVATE void SetIDCMPFlags4( struct Window *w, char *str )
  774. {
  775.    *str = '\0';
  776.  
  777.    if (CheckBit( w->IDCMPFlags, IDCMP_REQCLEAR ) == TRUE)
  778.       strcpy( str, "IDCMP_REQCLEAR " );
  779.  
  780.    if (CheckBit( w->IDCMPFlags, IDCMP_MENUVERIFY ) == TRUE)
  781.       strcat( str, "IDCMP_MENUVERIFY " );
  782.  
  783.    if (CheckBit( w->IDCMPFlags, IDCMP_NEWPREFS ) == TRUE)
  784.       strcat( str, "IDCMP_NEWPREFS " );
  785.  
  786.    if (CheckBit( w->IDCMPFlags, IDCMP_DISKINSERTED ) == TRUE)
  787.       strcat( str, "IDCMP_DISKINSERTED" );
  788.  
  789.    return;
  790. }
  791.  
  792. PRIVATE void SetIDCMPFlags5( struct Window *w, char *str )
  793. {
  794.    *str = '\0';
  795.  
  796.    if (CheckBit( w->IDCMPFlags, IDCMP_DISKREMOVED ) == TRUE)
  797.       strcpy( str, "IDCMP_DISKREMOVED " );
  798.  
  799.    if (CheckBit( w->IDCMPFlags, IDCMP_WBENCHMESSAGE ) == TRUE)
  800.       strcat( str, "IDCMP_WBENCHMESSAGE " );
  801.  
  802.    if (CheckBit( w->IDCMPFlags, IDCMP_ACTIVEWINDOW ) == TRUE)
  803.       strcat( str, "IDCMP_ACTIVEWINDOW " );
  804.  
  805.    if (CheckBit( w->IDCMPFlags, IDCMP_INACTIVEWINDOW ) == TRUE)
  806.       strcat( str, "IDCMP_INACTIVEWINDOW" );
  807.  
  808.    return;
  809. }
  810.  
  811. PRIVATE void SetIDCMPFlags6( struct Window *w, char *str )
  812. {
  813.    *str = '\0';
  814.  
  815.    if (CheckBit( w->IDCMPFlags, IDCMP_DELTAMOVE ) == TRUE)
  816.       strcpy( str, "IDCMP_DELTAMOVE " );
  817.  
  818.    if (CheckBit( w->IDCMPFlags, IDCMP_VANILLAKEY ) == TRUE)
  819.       strcat( str, "IDCMP_VANILLAKEY " );
  820.  
  821.    if (CheckBit( w->IDCMPFlags, IDCMP_INTUITICKS ) == TRUE)
  822.       strcat( str, "IDCMP_INTUITICKS " );
  823.  
  824.    if (CheckBit( w->IDCMPFlags, IDCMP_IDCMPUPDATE ) == TRUE)
  825.       strcat( str, "IDCMP_IDCMPUPDATE" );
  826.  
  827.    return;
  828. }
  829.  
  830. PRIVATE void SetIDCMPFlags7( struct Window *w, char *str )
  831. {
  832.    *str = '\0';
  833.  
  834.    if (CheckBit( w->IDCMPFlags, IDCMP_MENUHELP ) == TRUE)
  835.       strcpy( str, "IDCMP_MENUHELP " );
  836.  
  837.    if (CheckBit( w->IDCMPFlags, IDCMP_CHANGEWINDOW ) == TRUE)
  838.       strcat( str, "IDCMP_CHANGEWINDOW " );
  839.  
  840.    if (CheckBit( w->IDCMPFlags, IDCMP_GADGETHELP ) == TRUE)
  841.       strcat( str, "IDCMP_GADGETHELP" );
  842.  
  843.    return;
  844. }
  845.  
  846.  
  847. PRIVATE char bf[82], *itxt  = &bf[0];
  848. PRIVATE char tx[82], *title = &tx[0];
  849.  
  850. PRIVATE void DisplayStructure( void *ptr, int struct_type )
  851. {
  852.    struct Screen *s = NULL;
  853.    struct Window *w = NULL;
  854.    struct Task   *t = NULL;
  855.   
  856.    int            bgad, sgad, pgad, m, mi;
  857.   
  858.    bgad = sgad = pgad = m = mi = 0;
  859.    
  860.    switch (struct_type)
  861.       {
  862.       case 0: // Screen data:
  863.          s = (struct Screen *) ptr;
  864.  
  865.          sprintf( title, "SCREEN: (%08LX) %s", s, s->Title );
  866.          DisplayTitle( IWnd, title );
  867.  
  868.          sprintf( itxt, "DefaultTitle: %s", s->DefaultTitle );
  869.          WriteText( itxt, XPOS, StrYPos[0], 2 ); 
  870.  
  871.          sprintf( itxt, "Left     : %3u Top       : %3u Width: %4u Height: %4u", 
  872.                   s->LeftEdge, s->TopEdge, s->Width, s->Height 
  873.                 );
  874.          WriteText( itxt, XPOS, StrYPos[1], 1 ); 
  875.  
  876.          sprintf( itxt, "WBorLeft : %3u WBorTop   : %3u", 
  877.                   s->WBorLeft, s->WBorTop
  878.                 );
  879.          WriteText( itxt, XPOS, StrYPos[2], 1 ); 
  880.  
  881.          sprintf( itxt, "WBorRight: %3u WBorBottom: %3u", 
  882.                   s->WBorRight, s->WBorBottom
  883.                 );
  884.          WriteText( itxt, XPOS, StrYPos[3], 1 ); 
  885.  
  886.          sprintf( itxt, "DetailPen: %3u BlockPen  : %3u", 
  887.                   s->DetailPen, s->BlockPen
  888.                 );
  889.          WriteText( itxt, XPOS, StrYPos[4], 1 ); 
  890.  
  891.          sprintf( itxt, "ViewPort  : %08LX RastPort   : %08LX", 
  892.                   s->ViewPort, s->RastPort
  893.                 );
  894.          WriteText( itxt, XPOS, StrYPos[5], 1 ); 
  895.  
  896.          sprintf( itxt, "BitMap    : %08LX LayerInfo  : %08LX", 
  897.                   s->BitMap, s->LayerInfo
  898.                 );
  899.          WriteText( itxt, XPOS, StrYPos[6], 1 ); 
  900.  
  901.          sprintf( itxt, "ExtData   : %08LX UserData   : %08LX", 
  902.                   s->ExtData, s->UserData
  903.                 );
  904.          WriteText( itxt, XPOS, StrYPos[7], 1 ); 
  905.  
  906.          sprintf( itxt, "NextScreen: %08LX FirstWindow: %08LX", 
  907.                   s->NextScreen, s->FirstWindow
  908.                 );
  909.          WriteText( itxt, XPOS, StrYPos[8], 2 ); 
  910.  
  911.          sprintf( itxt, "BarHeight  : %3u BarVBorder : %3u BarHBorder: %3u", 
  912.                   s->BarHeight, s->BarVBorder, s->BarHBorder
  913.                 );
  914.          WriteText( itxt, XPOS, StrYPos[9], 1 ); 
  915.  
  916.          sprintf( itxt, "MenuVBorder: %3u MenuHBorder: %3u", 
  917.                   s->MenuVBorder, s->MenuHBorder
  918.                 );
  919.          WriteText( itxt, XPOS, StrYPos[10], 1 ); 
  920.  
  921.          WriteText( "Flags:", XPOS, StrYPos[11], 3 );
  922.          
  923.          SetScreenFlagString( itxt, s );
  924.          WriteText( itxt, XPOS, StrYPos[12], 1 );
  925.  
  926.          WriteText( "ViewModes:", XPOS, StrYPos[13], 3 );
  927.  
  928.          SetScreenViewMode1( itxt, s );
  929.          WriteText( itxt, XPOS, StrYPos[14], 1 );
  930.  
  931.          SetScreenViewMode2( itxt, s );
  932.          WriteText( itxt, XPOS, StrYPos[15], 1 );
  933.  
  934.          WriteText( "Press Close Gadget when you're done!", 
  935.                     150, StrYPos[16], 2 
  936.                   ); 
  937.          break;
  938.  
  939.       case 1: // Window data:
  940.          w = (struct Window *) ptr;
  941.  
  942.          sprintf( title, "WINDOW: (%08LX) %s", w, w->Title );
  943.          DisplayTitle( IWnd, title );
  944.  
  945.          sprintf( itxt, "WScreen: %08LX -> %s", 
  946.                   w->WScreen, w->WScreen->Title 
  947.                 );
  948.          WriteText( itxt, XPOS, StrYPos[0], 2 ); 
  949.  
  950.          sprintf( itxt, "Left    : %3u Top      : %3u Width    : %5u Height   : %5u",
  951.                   w->LeftEdge, w->TopEdge, w->Width, w->Height 
  952.                 );
  953.          WriteText( itxt, XPOS, StrYPos[1], 1 ); 
  954.  
  955.          sprintf( itxt, "MinWidth: %3u MinHeight: %3u MaxWidth : %5u MaxHeight: %5u",
  956.                   w->MinWidth, w->MinHeight, w->MaxWidth, w->MaxHeight 
  957.                 );
  958.          WriteText( itxt, XPOS, StrYPos[2], 1 ); 
  959.  
  960.          sprintf( itxt, "BdrLeft : %3u BdrTop   : %3u BdrRight : %5u BdrBottom: %5u",
  961.                   w->BorderLeft, w->BorderTop, 
  962.                   w->BorderRight, w->BorderBottom
  963.                 );
  964.          WriteText( itxt, XPOS, StrYPos[3], 1 ); 
  965.  
  966.          sprintf( itxt, "XOffset : %3u YOffset  : %3u DetailPen: %5u BlockPen : %5u",
  967.                   w->XOffset, w->YOffset, w->DetailPen, w->BlockPen
  968.                 );
  969.          WriteText( itxt, XPOS, StrYPos[4], 1 ); 
  970.  
  971.          sprintf( itxt, "CheckMark: %08LX ExtData: %08LX UserData: %08LX",
  972.                   w->CheckMark, w->ExtData, w->UserData
  973.                 );
  974.          WriteText( itxt, XPOS, StrYPos[5], 2 ); 
  975.  
  976.          CountGadgets( w, &bgad, &sgad, &pgad );
  977.  
  978.          sprintf( itxt, "BoolGadgets: %2u StrGadgets: %4u PropGadgets: %2u",
  979.                   bgad, sgad, pgad
  980.                 );
  981.          WriteText( itxt, XPOS, StrYPos[6], 1 ); 
  982.  
  983.          CountMenus( w, &m, &mi );
  984.  
  985.          sprintf( itxt, "Menus      : %2u MenuItems : %4u", m, mi );
  986.          WriteText( itxt, XPOS, StrYPos[7], 1 ); 
  987.  
  988.          t = (struct Task *) w->UserPort->mp_SigTask;
  989.  
  990.          sprintf( itxt, "UserPort  : %08LX -> mp_SigTask: %08LX, %-30.30s",
  991.                   w->UserPort, w->UserPort->mp_SigTask,
  992.                   (t == NULL ? " " : t->tc_Node.ln_Name)
  993.                 );
  994.          WriteText( itxt, XPOS, StrYPos[8], 2 ); 
  995.  
  996.          t = (struct Task *) w->WindowPort->mp_SigTask;
  997.          
  998.          sprintf( itxt, "WindowPort: %08LX -> mp_SigTask: %08LX, %-30.30s",
  999.                   w->WindowPort, w->WindowPort->mp_SigTask,
  1000.                   (t == NULL ? " " : t->tc_Node.ln_Name) 
  1001.                 );
  1002.          WriteText( itxt, XPOS, StrYPos[9], 2 ); 
  1003.  
  1004.          sprintf( itxt, "PtrHeight: %3u PtrWidth: %2u Pointer: %08LX",
  1005.                   w->PtrHeight, w->PtrWidth, w->Pointer
  1006.                 );
  1007.          WriteText( itxt, XPOS, StrYPos[10], 1 ); 
  1008.  
  1009.          sprintf( itxt, "ReqCount : %3u NextWindow: %08LX",
  1010.                   w->ReqCount, w->NextWindow
  1011.                 );
  1012.          WriteText( itxt, XPOS, StrYPos[11], 1 ); 
  1013.  
  1014.          WriteText( "Flags:", XPOS, StrYPos[12], 3 );
  1015.  
  1016.          SetWindowFlags1( w, itxt );
  1017.          WriteText( itxt, XPOS, StrYPos[13], 1 ); 
  1018.  
  1019.          SetWindowFlags2( w, itxt );
  1020.          WriteText( itxt, XPOS, StrYPos[14], 1 ); 
  1021.  
  1022.          SetWindowFlags3( w, itxt );
  1023.          WriteText( itxt, XPOS, StrYPos[15], 1 ); 
  1024.  
  1025.          SetWindowFlags4( w, itxt );
  1026.          WriteText( itxt, XPOS, StrYPos[16], 1 ); 
  1027.  
  1028.          WriteText( "IDCMPFlags:", XPOS, StrYPos[17], 3 );
  1029.  
  1030.          SetIDCMPFlags1( w, itxt );
  1031.          WriteText( itxt, XPOS, StrYPos[18], 1 ); 
  1032.  
  1033.          SetIDCMPFlags2( w, itxt );
  1034.          WriteText( itxt, XPOS, StrYPos[19], 1 ); 
  1035.  
  1036.          SetIDCMPFlags3( w, itxt );
  1037.          WriteText( itxt, XPOS, StrYPos[20], 1 ); 
  1038.  
  1039.          SetIDCMPFlags4( w, itxt );
  1040.          WriteText( itxt, XPOS, StrYPos[21], 1 ); 
  1041.  
  1042.          SetIDCMPFlags5( w, itxt );
  1043.          WriteText( itxt, XPOS, StrYPos[22], 1 ); 
  1044.  
  1045.          SetIDCMPFlags6( w, itxt );
  1046.          WriteText( itxt, XPOS, StrYPos[23], 1 ); 
  1047.  
  1048.          SetIDCMPFlags7( w, itxt );
  1049.          WriteText( itxt, XPOS, StrYPos[24], 1 ); 
  1050.  
  1051.          WriteText( "Press Close Gadget when you're done!", 
  1052.                     150, StrYPos[25], 2 
  1053.                   ); 
  1054.          break;
  1055.       
  1056.       case 2: // Task structure:
  1057.          WriteTask( ptr );
  1058.          break;
  1059.  
  1060.       case 3: // Process structure:
  1061.          WriteTask( ptr );
  1062.          break;
  1063.       }
  1064.  
  1065.    return;
  1066. }
  1067.  
  1068.  
  1069. PRIVATE int OpenIWindow( int numlines )
  1070. {
  1071.    UWORD wleft = ILeft, wtop = ITop, ww, wh;
  1072.    int   i;
  1073.    
  1074.    ComputeFont( Scr, Font, &CFont, IWidth, IHeight );
  1075.  
  1076.    IHeight = (numlines + 1) * (CFont.FontY + 3) + 2;
  1077.  
  1078.    if (IHeight > MAX_HEIGHT)
  1079.       IHeight = MAX_HEIGHT;
  1080.  
  1081.    for (i = 0; i < 32; i++)
  1082.       StrYPos[i] = 16 + i * (CFont.FontY + 3);
  1083.          
  1084.    ww = ComputeX( CFont.FontX, IWidth  );
  1085.    wh = ComputeY( CFont.FontY, IHeight );
  1086.  
  1087.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width) 
  1088.       wleft = Scr->Width - ww;
  1089.  
  1090.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height) 
  1091.       wtop = Scr->Height - wh;
  1092.  
  1093.    if ( !(IWnd = OpenWindowTags( NULL,
  1094.  
  1095.                    WA_Left,        wleft,
  1096.                    WA_Top,         wtop,
  1097.                    WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  1098.                    WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  1099.                    WA_IDCMP,       BUTTONIDCMP | IDCMP_GADGETUP
  1100.                      | IDCMP_REFRESHWINDOW | IDCMP_CLOSEWINDOW,
  1101.  
  1102.                    WA_Flags,       WFLG_SMART_REFRESH | WFLG_CLOSEGADGET 
  1103.                      | WFLG_ACTIVATE | WFLG_RMBTRAP,
  1104.  
  1105.                    WA_Gadgets,     NULL,
  1106.                    WA_Title,       IWTitle,
  1107.                    WA_ScreenTitle, ScrTitle,
  1108.                    TAG_DONE ))
  1109.       )
  1110.       return( -4 );
  1111.  
  1112.    return( 0 );
  1113. }
  1114.  
  1115. PRIVATE void CloseIWindow( void )
  1116. {
  1117.    if (IWnd != NULL) 
  1118.       {
  1119.       CloseWindow( IWnd );
  1120.       IWnd = NULL;
  1121.       }
  1122.  
  1123.    return;
  1124. }
  1125.  
  1126. PRIVATE int ICloseWindow( void )
  1127. {
  1128.    CloseIWindow();
  1129.    return( (int) FALSE );
  1130. }
  1131.  
  1132. PRIVATE int HandleInfoIDCMP( void )
  1133. {
  1134.    struct IntuiMessage    *m;
  1135.    BOOL            running = TRUE;
  1136.  
  1137.    while (running == TRUE)
  1138.       {
  1139.       if ((m = (struct IntuiMessag *) GetMsg( IWnd->UserPort )) == NULL)
  1140.          {
  1141.          (void) Wait( 1L << IWnd->UserPort->mp_SigBit );
  1142.          continue;
  1143.          }
  1144.  
  1145.       CopyMem( (char *) m, (char *) &IMsg, 
  1146.                (long) sizeof( struct IntuiMessage )
  1147.              );
  1148.  
  1149.       ReplyMsg( (struct Message *) m );
  1150.  
  1151.       switch (IMsg.Class) 
  1152.          {
  1153.         case IDCMP_CLOSEWINDOW:
  1154.            running = ICloseWindow();
  1155.             break;
  1156.          }
  1157.       }
  1158.  
  1159.    return( running );
  1160. }
  1161.  
  1162.  
  1163. PRIVATE int HandleWindowInfo( void *structptr, int whichdisplay )
  1164. {
  1165.    int rval = 0;
  1166.    
  1167.    switch (whichdisplay)
  1168.       {
  1169.       case 0: // Screen data:
  1170.          rval = OpenIWindow( 16 );
  1171.          break;
  1172.  
  1173.       case 1: // Window data:
  1174.          rval = OpenIWindow( 25 );
  1175.          break;
  1176.  
  1177.       case 2: // Task data:
  1178.          rval = OpenIWindow( 13 );
  1179.          break;
  1180.  
  1181.       case 3: // Process data:
  1182.          rval = OpenIWindow( 28 );
  1183.          break;
  1184.       }
  1185.    
  1186.    if (rval < 0)
  1187.       {
  1188.       (void) Handle_Problem( "Couldn't open Information Window!", 
  1189.                              "Allocation Problem:", NULL 
  1190.                            );
  1191.       return( -1 );
  1192.       }
  1193.  
  1194.    DisplayStructure( structptr, whichdisplay );
  1195.       
  1196.    (void) HandleInfoIDCMP();
  1197.  
  1198.    return( 0 );
  1199. }
  1200.  
  1201. PRIVATE int CountWindows( struct Screen *scr )
  1202. {
  1203.    struct Window *w    = NULL;
  1204.    int            rval = 0;
  1205.    
  1206.    if (scr != NULL)
  1207.       w = scr->FirstWindow;
  1208.    else
  1209.       return( rval );
  1210.  
  1211.    while (w != NULL)
  1212.       {
  1213.       rval++;
  1214.       w = w->NextWindow;
  1215.       }
  1216.  
  1217.    return( rval );
  1218. }
  1219.  
  1220. PRIVATE int CountScreens( struct Screen *firstscreen )
  1221. {
  1222.    int rval = 0;
  1223.    
  1224.    while (firstscreen != NULL)
  1225.       {
  1226.       rval++;
  1227.       firstscreen = firstscreen->NextScreen;
  1228.       }
  1229.  
  1230.    return( rval );
  1231. }
  1232.  
  1233. PRIVATE int MakeScrWindowList( void )
  1234. {
  1235.    struct Screen *firstscr  = NULL;
  1236.    struct Screen *tempscr   = NULL;
  1237.    struct Screen *activescr = NULL;
  1238.    struct Window *activewnd = NULL;
  1239.    struct Screen *s         = NULL;
  1240.  
  1241.    ULONG          ilock       = 0L;
  1242.    int            i, numitems = 0;
  1243.    int            j, scrcount = 0;
  1244.  
  1245.    /* The following code works without the calls to LockIBase() &
  1246.    ** UnlockIBase() just fine.  They are here just in case:
  1247.    */
  1248.  
  1249.    ilock = LockIBase( 0 );
  1250.  
  1251.      firstscr  = IntuitionBase->FirstScreen;
  1252.      activescr = IntuitionBase->ActiveScreen;
  1253.      activewnd = IntuitionBase->ActiveWindow;
  1254.      scrcount  = CountScreens( firstscr );
  1255.      tempscr   = firstscr;     
  1256.      numitems  = scrcount;
  1257.           
  1258.      for (j = 0; j < scrcount; j++)
  1259.         {
  1260.         numitems += CountWindows( tempscr );
  1261.         tempscr   = tempscr->NextScreen;
  1262.         }
  1263.  
  1264.      s = firstscr;
  1265.      i = 1;
  1266.  
  1267.      do {
  1268.         struct Window *w = s->FirstWindow;
  1269.  
  1270.         if (s == activescr)
  1271.            sprintf( &NodeStrs[ i++ * NODELENGTH ], 
  1272.                     "%08LX+ %3u,%3u %4u,%4u %08LX 00000000 S: %-30.30s",
  1273.                     s, s->LeftEdge, s->TopEdge, s->Width, s->Height,
  1274.                     s->Flags, s->Title
  1275.                   );
  1276.         else
  1277.            sprintf( &NodeStrs[ i++ * NODELENGTH ], 
  1278.                     "%08LX  %3u,%3u %4u,%4u %08LX 00000000 S: %-30.30s",
  1279.                     s, s->LeftEdge, s->TopEdge, s->Width, s->Height,
  1280.                     s->Flags, s->Title
  1281.                   );
  1282.         do {
  1283.  
  1284.            if (w == activewnd)
  1285.               sprintf( &NodeStrs[ i++ * NODELENGTH ], 
  1286.                        "%08LX+ %3u,%3u %4u,%4u %08LX %08LX W: %-30.30s",
  1287.                        w, w->LeftEdge, w->TopEdge, w->Width, w->Height,
  1288.                        w->Flags, w->IDCMPFlags, w->Title
  1289.                      );
  1290.            else
  1291.               sprintf( &NodeStrs[ i++ * NODELENGTH ], 
  1292.                        "%08LX  %3u,%3u %4u,%4u %08LX %08LX W: %-30.30s",
  1293.                        w, w->LeftEdge, w->TopEdge, w->Width, w->Height,
  1294.                        w->Flags, w->IDCMPFlags, w->Title
  1295.                      );
  1296.            
  1297.            w = w->NextWindow;
  1298.  
  1299.            } while ((w != NULL) && (i <= MAXNODE));
  1300.  
  1301.         s = s->NextScreen;
  1302.  
  1303.         } while ((s != NULL) && (i <= MAXNODE));
  1304.         
  1305.    UnlockIBase( ilock );
  1306.  
  1307.    return( numitems );
  1308. }
  1309.  
  1310. PRIVATE BOOL IsScreen( ULONG address )
  1311. {
  1312.    struct Screen *scr   = NULL;
  1313.  
  1314.    ULONG          ilock = 0L;
  1315.    BOOL           rval  = FALSE;
  1316.     
  1317.    ilock = LockIBase( 0 );
  1318.  
  1319.      scr  = IntuitionBase->FirstScreen;
  1320.  
  1321.      while (scr != NULL)
  1322.         {
  1323.         if (scr == (struct Screen *) address)
  1324.            {
  1325.            rval = TRUE;
  1326.            break;
  1327.            }
  1328.  
  1329.         scr = scr->NextScreen;
  1330.         }
  1331.      
  1332.    UnlockIBase( ilock );
  1333.  
  1334.    return( rval );
  1335. }
  1336.  
  1337. PRIVATE struct Window *selected_w = NULL;
  1338. PRIVATE struct Screen *selected_s = NULL;
  1339.  
  1340. PRIVATE int SLVClicked( int itemnum )
  1341. {
  1342.    ULONG addr = 0L;
  1343.    
  1344. //#  ifdef DEBUG
  1345. //   fprintf( stderr, "%-80.80s\n", ScrNodes[ itemnum ].ln_Name );
  1346. //#  endif
  1347.  
  1348.    if (itemnum == 0)   
  1349.       {
  1350.       GT_SetGadgetAttrs( ScrGadgets[ ScrMore ], Wnd, NULL,
  1351.                          GA_Disabled, TRUE, TAG_DONE 
  1352.                        );
  1353.  
  1354.       GT_SetGadgetAttrs( ScrGadgets[ ScrClose ], Wnd, NULL,
  1355.                          GA_Disabled, TRUE, TAG_DONE 
  1356.                        );
  1357.  
  1358.       GT_SetGadgetAttrs( ScrGadgets[ ScrSelection ], Wnd, NULL,
  1359.                          GTTX_Text, NULL,
  1360.                          TAG_DONE
  1361.                        );
  1362.  
  1363.       return( (int) TRUE );
  1364.       }
  1365.    else
  1366.       {
  1367.       GT_SetGadgetAttrs( ScrGadgets[ ScrMore ], Wnd, NULL,
  1368.                          GA_Disabled, FALSE, TAG_DONE 
  1369.                        );
  1370.  
  1371.       GT_SetGadgetAttrs( ScrGadgets[ ScrClose ], Wnd, NULL,
  1372.                          GA_Disabled, FALSE, TAG_DONE 
  1373.                        );
  1374.  
  1375.       GT_SetGadgetAttrs( ScrGadgets[ ScrSelection ], Wnd, NULL,
  1376.                          GTTX_Text, ScrNodes[ itemnum ].ln_Name, 
  1377.                          TAG_DONE
  1378.                        );
  1379.  
  1380.       // Now get address from the item & determine if it's a screen or
  1381.       // window.  Then set selected_s or selected_w.
  1382.       (void) stch_l( ScrNodes[ itemnum ].ln_Name, (long *) &addr );
  1383.       
  1384.       if (IsScreen( addr ) == TRUE)
  1385.          {
  1386.          selected_s = (struct Screen *) addr;
  1387.          selected_w = NULL;
  1388.          }
  1389.       else
  1390.          {
  1391.          selected_s = NULL;
  1392.          selected_w = (struct Window *) addr;
  1393.          }
  1394.       }
  1395.  
  1396.    return( (int) TRUE );
  1397. }
  1398.  
  1399.  
  1400. PRIVATE int UpdateClicked( int dummy )
  1401. {
  1402.    int i;
  1403.    
  1404.    GT_SetGadgetAttrs( ScrGadgets[ ScrSelection ], Wnd, NULL,
  1405.                       GTTX_Text, NULL,
  1406.                       TAG_DONE
  1407.                     );
  1408.  
  1409.    for (i = 1; i < MAXNODE; i++)          // 0 = ListView title string.
  1410.        NodeStrs[ i * NODELENGTH ] = '\0'; // Kill old ListView strings.
  1411.  
  1412.    (void) MakeScrWindowList();    // Remake ListView strings.
  1413.  
  1414.    GT_SetGadgetAttrs( ScrGadgets[ ScrLV ], Wnd, NULL,
  1415.                       GTLV_Selected, 0, TAG_DONE
  1416.                     );
  1417.    
  1418.    GT_RefreshWindow( Wnd, NULL );
  1419.  
  1420.    return( (int) TRUE );
  1421. }
  1422.  
  1423. PRIVATE int MoreClicked( int dummy )
  1424. {
  1425.    if (selected_s != NULL)
  1426.       {
  1427.       // Show all of the Screen Information:
  1428.       (void) HandleWindowInfo( (void *) selected_s, 0 );
  1429.       }
  1430.    else if (selected_w != NULL)
  1431.       {
  1432.       // Show all of the Window Information:
  1433.       (void) HandleWindowInfo( (void *) selected_w, 1 );
  1434.       }
  1435.    else
  1436.       {
  1437.       // Some sort of error:
  1438.       (void) Handle_Problem( "MoreClicked() internal error condition!",
  1439.                              "SysScreens() Internal ERROR:", NULL
  1440.                            );
  1441.       }   
  1442.  
  1443.    return( (int) TRUE );
  1444. }
  1445.  
  1446. PRIVATE BOOL CheckWindow( struct Window *findwin )
  1447. {
  1448.   struct Window *win;
  1449.   struct Screen *scr;
  1450.   ULONG          lock = 0L;
  1451.   BOOL           ret  = FALSE;
  1452.  
  1453.   lock = LockIBase( NULL );
  1454.  
  1455.   scr = IntuitionBase->FirstScreen;
  1456.   
  1457.   while ((scr != NULL) && (ret == FALSE))
  1458.      {
  1459.      win = scr->FirstWindow;
  1460.      
  1461.      while (win != NULL)
  1462.         {
  1463.         if (win == findwin)
  1464.            {
  1465.            ret = TRUE;
  1466.            break;
  1467.            }
  1468.  
  1469.         win = win->NextWindow;
  1470.         }
  1471.  
  1472.      scr = scr->NextScreen;
  1473.      }
  1474.  
  1475.   UnlockIBase( lock );
  1476.  
  1477.   return( ret );
  1478. }
  1479.  
  1480. PRIVATE BOOL CheckScreen( struct Screen *findscr )
  1481. {
  1482.   struct Screen *scr;
  1483.   ULONG          lock = 0L;
  1484.   BOOL           ret  = FALSE;
  1485.  
  1486.   lock = LockIBase( NULL );
  1487.  
  1488.   scr = IntuitionBase->FirstScreen;
  1489.  
  1490.   while (scr != NULL)
  1491.      { 
  1492.      if (scr == findscr)
  1493.         {
  1494.         ret = TRUE;
  1495.         break;
  1496.         } 
  1497.  
  1498.      scr = scr->NextScreen;
  1499.      }
  1500.  
  1501.   UnlockIBase( lock );
  1502.  
  1503.   return( ret );
  1504. }
  1505.  
  1506. PUBLIC void CloseTheWindow( struct Window *wind )
  1507. {
  1508.    if (CheckWindow( wind ) == TRUE)
  1509.       {
  1510.       if ((wind->ReqCount != 0) && wind->FirstRequest)
  1511.          {
  1512.          while (wind->ReqCount != 0)
  1513.             EndRequest( wind->FirstRequest, wind );
  1514.          }
  1515.  
  1516.       if (wind->DMRequest != NULL)
  1517.          ClearDMRequest( wind );
  1518.  
  1519.       if (wind->Pointer != NULL)
  1520.          ClearPointer( wind );
  1521.  
  1522.       if (wind->MenuStrip != NULL)
  1523.          ClearMenuStrip( wind );
  1524.  
  1525.       CloseWindow( wind );
  1526.       }
  1527.  
  1528.    return;
  1529. }
  1530.  
  1531. PUBLIC void CloseTheScreen( struct Screen *scr )
  1532. {
  1533.   struct Window *win = scr->FirstWindow, *markwin;
  1534.  
  1535.   if (CheckScreen( scr ) == TRUE)
  1536.      {
  1537.      while (win != NULL)
  1538.         {
  1539.         markwin = win->NextWindow;
  1540.         CloseTheWindow( win );
  1541.         win     = markwin;
  1542.     }
  1543.  
  1544.      CloseScreen( scr );
  1545.      }
  1546.  
  1547.    return;
  1548. }
  1549.  
  1550. PRIVATE int CloseClicked( int dummy )
  1551. {
  1552.    // Check selected_s & selected_w for a non-NULL value
  1553.    char ErrMsg[256];
  1554.    
  1555.    if (selected_s != NULL)
  1556.       {
  1557.       sprintf( ErrMsg, "Are you SURE you want to close %08lx?", 
  1558.                         selected_s
  1559.              );
  1560.  
  1561.       if (SanityCheck( ErrMsg ) == TRUE)
  1562.          {
  1563.          if (selected_s == Scr)
  1564.             {
  1565.             (void) Handle_Problem( "Screen %08lx CANNOT be closed!",
  1566.                                    "User ERROR:", (int *) &Scr
  1567.                                  );
  1568.  
  1569.             return( (int) TRUE );
  1570.             }
  1571.  
  1572.          CloseTheScreen( selected_s );
  1573.  
  1574.          (void) MakeScrWindowList();
  1575.          GT_RefreshWindow( Wnd, NULL );
  1576.          }
  1577.       else
  1578.          return( (int) TRUE );
  1579.       }
  1580.    else if (selected_w != NULL)
  1581.       {
  1582.       sprintf( ErrMsg, "Are you SURE you want to close %08lx?", 
  1583.                         selected_w
  1584.              );
  1585.  
  1586.       if (SanityCheck( ErrMsg ) == TRUE)
  1587.          {
  1588.          if (selected_w == Wnd)
  1589.             {
  1590.             (void) Handle_Problem( "Window %08lx CANNOT be closed!",
  1591.                                    "User ERROR:", (int *) &Wnd
  1592.                                  );
  1593.  
  1594.             return( (int) TRUE );
  1595.             }
  1596.  
  1597.          CloseTheWindow( selected_w );
  1598.  
  1599.          (void) MakeScrWindowList();
  1600.          GT_RefreshWindow( Wnd, NULL );
  1601.          }
  1602.       else
  1603.          return( (int) TRUE );
  1604.       }
  1605.    else
  1606.       {
  1607.       // Some sort of error:
  1608.       UserInfo( "CloseClicked() internal error condition!",
  1609.                 "SysScreens() Internal ERROR:"
  1610.               );
  1611.  
  1612.       return( (int) TRUE );
  1613.       }   
  1614.  
  1615.    return( (int) TRUE );
  1616. }
  1617.  
  1618. PRIVATE void CloseScrWindow( void )
  1619. {
  1620.    if (Wnd)
  1621.       {
  1622.       CloseWindow( Wnd );
  1623.       Wnd = NULL;
  1624.       }
  1625.  
  1626.    if (GList)
  1627.       {
  1628.       FreeGadgets( GList );
  1629.       GList = NULL;
  1630.       }
  1631.  
  1632.    if (TFont)
  1633.       {
  1634.       CloseFont( TFont );
  1635.       TFont = NULL;
  1636.       }
  1637.  
  1638.    return;
  1639. }
  1640.  
  1641. PRIVATE int ScrCloseWindow( void )
  1642. {
  1643.    CloseScrWindow();
  1644.    return( (int) FALSE );
  1645. }
  1646.  
  1647. PRIVATE int CancelClicked( int dummy )
  1648. {
  1649.    return( ScrCloseWindow() );
  1650. }
  1651.  
  1652. PRIVATE int OpenScrWindow( void )
  1653. {
  1654.    struct NewGadget  ng;
  1655.    struct Gadget    *g;
  1656.    UWORD             lc, tc;
  1657.    UWORD             wleft = WLeft, wtop = WTop, ww, wh;
  1658.  
  1659.    ComputeFont( Scr, Font, &CFont, WWidth, WHeight );
  1660.  
  1661.    ww = ComputeX( CFont.FontX, WWidth );
  1662.    wh = ComputeY( CFont.FontY, WHeight );
  1663.  
  1664.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width)
  1665.       wleft = Scr->Width - ww;
  1666.  
  1667.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height)
  1668.       wtop = Scr->Height - wh;
  1669.  
  1670.    if ( !(TFont = OpenDiskFont( Font )))
  1671.       return( -5 );
  1672.  
  1673.    if ( !(g = CreateContext( &GList )))
  1674.       return( -1 );
  1675.  
  1676.    for (lc = 0, tc = 0; lc < SCR_CNT; lc++)
  1677.       {
  1678.       CopyMem( (char *) &ScrNGad[ lc ], (char *) &ng, 
  1679.                (long) sizeof( struct NewGadget )
  1680.              );
  1681.  
  1682.       ng.ng_VisualInfo = VisualInfo;
  1683.       ng.ng_TextAttr   = Font;
  1684.       ng.ng_LeftEdge   = CFont.OffX + ComputeX( CFont.FontX, 
  1685.                                                 ng.ng_LeftEdge 
  1686.                                               );
  1687.  
  1688.       ng.ng_TopEdge    = CFont.OffY + ComputeY( CFont.FontY, 
  1689.                                                 ng.ng_TopEdge 
  1690.                                               );
  1691.  
  1692.       ng.ng_Width      = ComputeX( CFont.FontX, ng.ng_Width  );
  1693.       ng.ng_Height     = ComputeY( CFont.FontY, ng.ng_Height );
  1694.  
  1695.       ScrGadgets[lc] = g = CreateGadgetA( (ULONG) ScrGTypes[lc], 
  1696.                             g, 
  1697.                             &ng, 
  1698.                             (struct TagItem *) &ScrGTags[tc] );
  1699.  
  1700.       while (ScrGTags[tc])
  1701.          tc += 2;
  1702.  
  1703.       tc++;
  1704.       if (NOT g)
  1705.          return( -2 );
  1706.       }
  1707.  
  1708.    if ( !(Wnd = OpenWindowTags( NULL,
  1709.  
  1710.                  WA_Left,        wleft,
  1711.                  WA_Top,         wtop,
  1712.                  WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  1713.                  WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  1714.                  WA_IDCMP,       LISTVIEWIDCMP | BUTTONIDCMP 
  1715.                    | IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW,
  1716.  
  1717.                  WA_Flags,       WFLG_DRAGBAR | WFLG_DEPTHGADGET 
  1718.                    | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH | WFLG_ACTIVATE 
  1719.                    | WFLG_RMBTRAP,
  1720.                  
  1721.                  WA_Gadgets,     GList,
  1722.                  WA_Title,       WTitle,
  1723.                  WA_ScreenTitle, ScrTitle,
  1724.                  TAG_DONE ))
  1725.       )
  1726.       return( -4 );
  1727.  
  1728.    GT_RefreshWindow( Wnd, NULL );
  1729.  
  1730.    return( 0 );
  1731. }
  1732.  
  1733. PRIVATE int HandleScrIDCMP( void )
  1734. {
  1735.    struct IntuiMessage *m;
  1736.    int                 (*func)( int );
  1737.    BOOL                running = TRUE;
  1738.  
  1739.    while (running == TRUE)
  1740.       {
  1741.       if ((m = GT_GetIMsg( Wnd->UserPort )) == NULL)
  1742.          {
  1743.          (void) Wait( 1L << Wnd->UserPort->mp_SigBit );
  1744.          continue;
  1745.          }
  1746.  
  1747.       CopyMem( (char *) m, (char *) &IMsg, 
  1748.                (long) sizeof( struct IntuiMessage ) 
  1749.              );
  1750.  
  1751.       GT_ReplyIMsg( m );
  1752.  
  1753.       switch (IMsg.Class)
  1754.          {
  1755.          case IDCMP_REFRESHWINDOW:
  1756.             GT_BeginRefresh( Wnd );
  1757.             GT_EndRefresh( Wnd, TRUE );
  1758.             break;
  1759.  
  1760.          case IDCMP_CLOSEWINDOW:
  1761.             running = ScrCloseWindow();
  1762.             break;
  1763.  
  1764.          case IDCMP_GADGETUP:
  1765.             func    = (void *) ((struct Gadget *) IMsg.IAddress)->UserData;
  1766.             running = func( (int) IMsg.Code );
  1767.             break;
  1768.          }
  1769.       }
  1770.  
  1771.    return( running );
  1772. }
  1773.  
  1774. PUBLIC int HandleScreenLV( void )
  1775. {
  1776.    int i = 0;
  1777.    
  1778.  
  1779.    if (SetupSystemList( &OpenScrWindow ) < 0)
  1780.       {
  1781.       (void) Handle_Problem( "Couldn't open a System ListViewer!", 
  1782.                              "Allocation Problem:", NULL 
  1783.                            );
  1784.       return( -1 );
  1785.       }
  1786.  
  1787.    SetNotifyWindow( Wnd ); // For Handle_Problem().
  1788.   
  1789.    lvm.lvm_NodeStrs   = &NodeStrs[0];
  1790.    lvm.lvm_Nodes      = &ScrNodes[0];
  1791.    lvm.lvm_NumItems   = MAXNODE;
  1792.    lvm.lvm_NodeLength = NODELENGTH;
  1793.  
  1794.    SetupList( &ScrList, &lvm );   
  1795.  
  1796.    strcpy( ScrNodes[0].ln_Name, ttl );
  1797.  
  1798.    (void) MakeScrWindowList();
  1799.  
  1800.    ModifyListView( ScrGadgets[ ScrLV ], Wnd, 
  1801.                    (struct List *) &ScrList, NULL
  1802.                  );
  1803.  
  1804.    GT_RefreshWindow( Wnd, NULL );
  1805.  
  1806.    (void) HandleScrIDCMP();
  1807.    
  1808.    ShutdownSystemList();
  1809.    return( 0 );
  1810. }
  1811.  
  1812. #ifdef DEBUG
  1813.  
  1814. PUBLIC int main( void )
  1815. {
  1816.    return( HandleScreenLV() );
  1817. }
  1818.  
  1819. #endif
  1820.  
  1821. /* --------------------- END of SysScreens.c file! -------------------- */
  1822.